#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <aclconio.h>
#include <define.h>
#include <transact.h>
#include <tran.h>
#include <gds.h>
#include <sizes.h>
#include "ConfProto.h"
#include "tblutil.h"
#include <\SOFTPAY\Ver30\source\include\sizes.h>
#include <\SOFTPAY\Ver30\HostSrc\citisrc\citiids.h>
#include <\SOFTPAY\Ver30\HostSrc\cpacsrc\cpacids.h>
#include <confio.h>

#include <\SOFTPAY\Ver30\source\include\TCT.h>



static void *storeFromStruct;

static int recordNum;
void registerTCT(void *ptr)
{
	 storeFromStruct = ptr;
}

void *dealWithAddressBoundary(void*address);
int	inLoadTCTRecFromStruct (int inRecNumber, void *vdStruct)
{
	int inRet;
	char* tmp = (char*)vdStruct;

	registerTCT(vdStruct);
	vdStruct = dealWithAddressBoundary(vdStruct);
	inRet = inLoadConfRec(TCT_FILENAME, SIZE_TCT_REC, inRecNumber, vdStruct);

	recordNum = inRecNumber;
	return inRet;
}

void vdRestoreTCTRecFromStruct(void *vdStruct)
{
	registerTCT(vdStruct);
	vdStruct = dealWithAddressBoundary(vdStruct);
	memcpy((char *) pvdGetTCTRec(), vdStruct, SIZE_TCT_REC);

}

void vdCopyTCTRecFromStruct(void *vdStruct)
{
	registerTCT(vdStruct);
	vdStruct = dealWithAddressBoundary(vdStruct);
		memcpy(vdStruct, (char *) pvdGetTCTRec(), SIZE_TCT_REC);

}

int	inSaveTCTRecFromStruct (int inRecNumber,  void *vdStruct)
{
	int inRet;

	registerTCT(vdStruct);
	vdStruct = dealWithAddressBoundary(vdStruct);
	inRet = inSaveConfRec(TCT_FILENAME, SIZE_TCT_REC, inRecNumber, (char *) vdStruct);

	return inRet;
}

int	inUpdateTCTRecFromStruct (void *vdStruct)
{
	int inRet;

	registerTCT(vdStruct);
	vdStruct = dealWithAddressBoundary(vdStruct);
	inRet = inSaveConfRec(TCT_FILENAME, SIZE_TCT_REC, recordNum, (char *) vdStruct);

	return inRet;
}

char* szGetSuperPwdFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetSuperPwd();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->szSuperPwd;
}

void vdSetSuperPwdFromStruct(const char* szSuperPwd, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetSuperPwd(szSuperPwd);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((TCT_REC*)vdStruct)->szSuperPwd, szSuperPwd, sizeof(((TCT_REC*)NULL)->szSuperPwd)-1);
}

char* szGetIdleLogoNameFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetIdleLogoName();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->szIdleLogoName;
}

void vdSetIdleLogoNameFromStruct(const char* szIdleLogoName, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetIdleLogoName(szIdleLogoName);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((TCT_REC*)vdStruct)->szIdleLogoName, szIdleLogoName, sizeof(((TCT_REC*)NULL)->szIdleLogoName)-1);
}

char* szGetTracksFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetTracks();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->szTracks;
}

void vdSetTracksFromStruct(const char* szTracks, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetTracks(szTracks);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((TCT_REC*)vdStruct)->szTracks, szTracks, sizeof(((TCT_REC*)NULL)->szTracks)-1);
}

char* szGetManagerPwdFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetManagerPwd();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->szManagerPwd;
}

void vdSetManagerPwdFromStruct(const char* szManagerPwd, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetManagerPwd(szManagerPwd);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((TCT_REC*)vdStruct)->szManagerPwd, szManagerPwd, sizeof(((TCT_REC*)NULL)->szManagerPwd)-1);
}

char* szGetDateFormatFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetDateFormat();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->szDateFormat;
}

void vdSetDateFormatFromStruct(const char* szDateFormat, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetDateFormat(szDateFormat);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((TCT_REC*)vdStruct)->szDateFormat, szDateFormat, sizeof(((TCT_REC*)NULL)->szDateFormat)-1);
}

char* szGetPABXCodeFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetPABXCode();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->szPABXCode;
}

void vdSetPABXCodeFromStruct(const char* szPABXCode, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetPABXCode(szPABXCode);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((TCT_REC*)vdStruct)->szPABXCode, szPABXCode, sizeof(((TCT_REC*)NULL)->szPABXCode)-1);
}

char* szGetForceOnLineTimeFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetForceOnLineTime();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->szForceOnLineTime;
}

void vdSetForceOnLineTimeFromStruct(const char* szForceOnLineTime, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetForceOnLineTime(szForceOnLineTime);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((TCT_REC*)vdStruct)->szForceOnLineTime, szForceOnLineTime, sizeof(((TCT_REC*)NULL)->szForceOnLineTime)-1);
}

char* szGetFallBackTimeFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetFallBackTime();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->szFallBackTime;
}

void vdSetFallBackTimeFromStruct(const char* szFallBackTime, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetFallBackTime(szFallBackTime);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((TCT_REC*)vdStruct)->szFallBackTime, szFallBackTime, sizeof(((TCT_REC*)NULL)->szFallBackTime)-1);
}

char* szGetTCTStrDummyFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetTCTStrDummy();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->szTCTStrDummy;
}

void vdSetTCTStrDummyFromStruct(const char* szTCTStrDummy, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetTCTStrDummy(szTCTStrDummy);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((TCT_REC*)vdStruct)->szTCTStrDummy, szTCTStrDummy, sizeof(((TCT_REC*)NULL)->szTCTStrDummy)-1);
}

char chGetCurrentShiftFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return chGetCurrentShift();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->chCurrentShift;
}

void vdSetCurrentShiftFromStruct(char chCurrentShift, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetCurrentShift(chCurrentShift);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->chCurrentShift = chCurrentShift;
}

short inGetPinBarBaudRateFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetPinBarBaudRate();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inPinBarBaudRate;
}

void vdSetPinBarBaudRateFromStruct(short inPinBarBaudRate, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetPinBarBaudRate(inPinBarBaudRate);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inPinBarBaudRate = inPinBarBaudRate;
}

short inGetPinBarDataFormatFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetPinBarDataFormat();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inPinBarDataFormat;
}

void vdSetPinBarDataFormatFromStruct(short inPinBarDataFormat, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetPinBarDataFormat(inPinBarDataFormat);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inPinBarDataFormat = inPinBarDataFormat;
}

short inGetTipPercentFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetTipPercent();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inTipPercent;
}

void vdSetTipPercentFromStruct(short inTipPercent, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetTipPercent(inTipPercent);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inTipPercent = inTipPercent;
}

short inGetTipProcessingFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetTipProcessing();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inTipProcessing;
}

void vdSetTipProcessingFromStruct(short inTipProcessing, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetTipProcessing(inTipProcessing);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inTipProcessing = inTipProcessing;
}

short inGetExcessTipFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetExcessTip();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inExcessTip;
}

void vdSetExcessTipFromStruct(short inExcessTip, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetExcessTip(inExcessTip);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inExcessTip = inExcessTip;
}

short inGetSugTipPer1FromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetSugTipPer1();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inSugTipPer1;
}

void vdSetSugTipPer1FromStruct(short inSugTipPer1, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetSugTipPer1(inSugTipPer1);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inSugTipPer1 = inSugTipPer1;
}

short inGetSugTipPer2FromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetSugTipPer2();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inSugTipPer2;
}

void vdSetSugTipPer2FromStruct(short inSugTipPer2, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetSugTipPer2(inSugTipPer2);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inSugTipPer2 = inSugTipPer2;
}

short inGetSugTipPer3FromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetSugTipPer3();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inSugTipPer3;
}

void vdSetSugTipPer3FromStruct(short inSugTipPer3, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetSugTipPer3(inSugTipPer3);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inSugTipPer3 = inSugTipPer3;
}

short inGetPPTimeOutFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetPPTimeOut();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inPPTimeOut;
}

void vdSetPPTimeOutFromStruct(short inPPTimeOut, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetPPTimeOut(inPPTimeOut);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inPPTimeOut = inPPTimeOut;
}

short inGetClerkModeFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetClerkMode();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inClerkMode;
}

void vdSetClerkModeFromStruct(short inClerkMode, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetClerkMode(inClerkMode);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inClerkMode = inClerkMode;
}

short inGetIdleTimeOutFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetIdleTimeOut();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inIdleTimeOut;
}

void vdSetIdleTimeOutFromStruct(short inIdleTimeOut, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetIdleTimeOut(inIdleTimeOut);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inIdleTimeOut = inIdleTimeOut;
}

short inGetOpenTabDAmtFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetOpenTabDAmt();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inOpenTabDAmt;
}

void vdSetOpenTabDAmtFromStruct(short inOpenTabDAmt, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetOpenTabDAmt(inOpenTabDAmt);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inOpenTabDAmt = inOpenTabDAmt;
}

short inGetZIDdownloadFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetZIDdownload();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inZIDdownload;
}

void vdSetZIDdownloadFromStruct(short inZIDdownload, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetZIDdownload(inZIDdownload);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inZIDdownload = inZIDdownload;
}

short inGetTipMaxAdjustFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetTipMaxAdjust();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inTipMaxAdjust;
}

void vdSetTipMaxAdjustFromStruct(short inTipMaxAdjust, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetTipMaxAdjust(inTipMaxAdjust);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inTipMaxAdjust = inTipMaxAdjust;
}

short inGetPerOverFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetPerOver();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inPerOver;
}

void vdSetPerOverFromStruct(short inPerOver, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetPerOver(inPerOver);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inPerOver = inPerOver;
}

short inGetSurChargeFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetSurCharge();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inSurCharge;
}

void vdSetSurChargeFromStruct(short inSurCharge, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetSurCharge(inSurCharge);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inSurCharge = inSurCharge;
}

short inGetAutoSettRetriesFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetAutoSettRetries();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inAutoSettRetries;
}

void vdSetAutoSettRetriesFromStruct(short inAutoSettRetries, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetAutoSettRetries(inAutoSettRetries);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inAutoSettRetries = inAutoSettRetries;
}

short inGetAutoSttlWaitTimeFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetAutoSttlWaitTime();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inAutoSttlWaitTime;
}

void vdSetAutoSttlWaitTimeFromStruct(short inAutoSttlWaitTime, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetAutoSttlWaitTime(inAutoSttlWaitTime);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inAutoSttlWaitTime = inAutoSttlWaitTime;
}

short inGetApplicationTypeFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetApplicationType();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inApplicationType;
}

void vdSetApplicationTypeFromStruct(short inApplicationType, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetApplicationType(inApplicationType);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inApplicationType = inApplicationType;
}

short inGetPINPadTypeFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetPINPadType();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inPINPadType;
}

void vdSetPINPadTypeFromStruct(short inPINPadType, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetPINPadType(inPINPadType);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inPINPadType = inPINPadType;
}

short inGetEncryptMethodFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetEncryptMethod();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inEncryptMethod;
}

void vdSetEncryptMethodFromStruct(short inEncryptMethod, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetEncryptMethod(inEncryptMethod);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inEncryptMethod = inEncryptMethod;
}

short inGetShiftTypeFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetShiftType();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inShiftType;
}

void vdSetShiftTypeFromStruct(short inShiftType, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetShiftType(inShiftType);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inShiftType = inShiftType;
}

short inGetDupCheckFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetDupCheck();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inDupCheck;
}

void vdSetDupCheckFromStruct(short inDupCheck, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetDupCheck(inDupCheck);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inDupCheck = inDupCheck;
}

short inGetLanguageIdxFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetLanguageIdx();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inLanguageIdx;
}

void vdSetLanguageIdxFromStruct(short inLanguageIdx, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetLanguageIdx(inLanguageIdx);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inLanguageIdx = inLanguageIdx;
}

short inGetNotifyTimeFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetNotifyTime();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inNotifyTime;
}

void vdSetNotifyTimeFromStruct(short inNotifyTime, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetNotifyTime(inNotifyTime);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inNotifyTime = inNotifyTime;
}

short inGetInvNumSizeFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetInvNumSize();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inInvNumSize;
}

void vdSetInvNumSizeFromStruct(short inInvNumSize, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetInvNumSize(inInvNumSize);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inInvNumSize = inInvNumSize;
}

short inGetEMVOnlineFlagFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetEMVOnlineFlag();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inEMVOnlineFlag;
}

void vdSetEMVOnlineFlagFromStruct(short inEMVOnlineFlag, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetEMVOnlineFlag(inEMVOnlineFlag);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inEMVOnlineFlag = inEMVOnlineFlag;
}

short inGetNumOfRingsFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetNumOfRings();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inNumOfRings;
}

void vdSetNumOfRingsFromStruct(short inNumOfRings, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetNumOfRings(inNumOfRings);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inNumOfRings = inNumOfRings;
}

short inGetECISupportFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetECISupport();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inECISupport;
}

void vdSetECISupportFromStruct(short inECISupport, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetECISupport(inECISupport);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inECISupport = inECISupport;
}

short inGetDockedModemTypeFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetDockedModemType();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inDockedModemType;
}

void vdSetDockedModemTypeFromStruct(short inDockedModemType, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetDockedModemType(inDockedModemType);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inDockedModemType = inDockedModemType;
}

short inGetExcessTabFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetExcessTab();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inExcessTab;
}

void vdSetExcessTabFromStruct(short inExcessTab, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetExcessTab(inExcessTab);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inExcessTab = inExcessTab;
}

long lnGetTaxPercentFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return lnGetTaxPercent();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->lnTaxPercent;
}

void vdSetTaxPercentFromStruct(long lnTaxPercent, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetTaxPercent(lnTaxPercent);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->lnTaxPercent = lnTaxPercent;
}

long lnGetReceiptLimitAmountFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return lnGetReceiptLimitAmount();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->lnReceiptLimitAmount;
}

void vdSetReceiptLimitAmountFromStruct(long lnReceiptLimitAmount, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetReceiptLimitAmount(lnReceiptLimitAmount);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->lnReceiptLimitAmount = lnReceiptLimitAmount;
}

long lnGetSignLimitAmountFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return lnGetSignLimitAmount();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->lnSignLimitAmount;
}

void vdSetSignLimitAmountFromStruct(long lnSignLimitAmount, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetSignLimitAmount(lnSignLimitAmount);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->lnSignLimitAmount = lnSignLimitAmount;
}

short inGetImamRestartMaxCountFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return inGetImamRestartMaxCount();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->inImamRestartMaxCount;
}

void vdSetImamRestartMaxCountFromStruct(short inImamRestartMaxCount, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamRestartMaxCount(inImamRestartMaxCount);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->inImamRestartMaxCount = inImamRestartMaxCount;
}

VS_BOOL fGetPINBypassFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetPINBypass();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fPINBypass;
}

void vdSetPINBypassFromStruct(VS_BOOL fPINBypass, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetPINBypass(fPINBypass);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fPINBypass = fPINBypass;
}

VS_BOOL fGetHHConfirmAmtFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetHHConfirmAmt();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fHHConfirmAmt;
}

void vdSetHHConfirmAmtFromStruct(VS_BOOL fHHConfirmAmt, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetHHConfirmAmt(fHHConfirmAmt);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fHHConfirmAmt = fHHConfirmAmt;
}

VS_BOOL fGetTerminalBeepFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetTerminalBeep();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fTerminalBeep;
}

void vdSetTerminalBeepFromStruct(VS_BOOL fTerminalBeep, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetTerminalBeep(fTerminalBeep);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fTerminalBeep = fTerminalBeep;
}

VS_BOOL fGetHourlyNotifyFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetHourlyNotify();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fHourlyNotify;
}

void vdSetHourlyNotifyFromStruct(VS_BOOL fHourlyNotify, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetHourlyNotify(fHourlyNotify);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fHourlyNotify = fHourlyNotify;
}

VS_BOOL fGetAutoSettleFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetAutoSettle();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fAutoSettle;
}

void vdSetAutoSettleFromStruct(VS_BOOL fAutoSettle, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetAutoSettle(fAutoSettle);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fAutoSettle = fAutoSettle;
}

VS_BOOL fGetTaxProcFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetTaxProc();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fTaxProc;
}

void vdSetTaxProcFromStruct(VS_BOOL fTaxProc, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetTaxProc(fTaxProc);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fTaxProc = fTaxProc;
}

VS_BOOL fGetOpenTabOptRecFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetOpenTabOptRec();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fOpenTabOptRec;
}

void vdSetOpenTabOptRecFromStruct(VS_BOOL fOpenTabOptRec, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetOpenTabOptRec(fOpenTabOptRec);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fOpenTabOptRec = fOpenTabOptRec;
}

VS_BOOL fGetCloseTabOptRecFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetCloseTabOptRec();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fCloseTabOptRec;
}

void vdSetCloseTabOptRecFromStruct(VS_BOOL fCloseTabOptRec, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetCloseTabOptRec(fCloseTabOptRec);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fCloseTabOptRec = fCloseTabOptRec;
}

VS_BOOL fGetTrainSettleFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetTrainSettle();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fTrainSettle;
}

void vdSetTrainSettleFromStruct(VS_BOOL fTrainSettle, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetTrainSettle(fTrainSettle);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fTrainSettle = fTrainSettle;
}

VS_BOOL fGetKeyboardLockFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetKeyboardLock();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fKeyboardLock;
}

void vdSetKeyboardLockFromStruct(VS_BOOL fKeyboardLock, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetKeyboardLock(fKeyboardLock);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fKeyboardLock = fKeyboardLock;
}

VS_BOOL fGetSameCardConfirmFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetSameCardConfirm();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fSameCardConfirm;
}

void vdSetSameCardConfirmFromStruct(VS_BOOL fSameCardConfirm, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetSameCardConfirm(fSameCardConfirm);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fSameCardConfirm = fSameCardConfirm;
}

VS_BOOL fGetDemoModeFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetDemoMode();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fDemoMode;
}

void vdSetDemoModeFromStruct(VS_BOOL fDemoMode, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetDemoMode(fDemoMode);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fDemoMode = fDemoMode;
}

VS_BOOL fGetManEntryPasswdFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetManEntryPasswd();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fManEntryPasswd;
}

void vdSetManEntryPasswdFromStruct(VS_BOOL fManEntryPasswd, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetManEntryPasswd(fManEntryPasswd);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fManEntryPasswd = fManEntryPasswd;
}

VS_BOOL fGetCashBackFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetCashBack();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fCashBack;
}

void vdSetCashBackFromStruct(VS_BOOL fCashBack, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetCashBack(fCashBack);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fCashBack = fCashBack;
}

VS_BOOL fGetMerchPWFlagFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetMerchPWFlag();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fMerchPWFlag;
}

void vdSetMerchPWFlagFromStruct(VS_BOOL fMerchPWFlag, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetMerchPWFlag(fMerchPWFlag);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fMerchPWFlag = fMerchPWFlag;
}

VS_BOOL fGetCounterPayTipFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetCounterPayTip();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fCounterPayTip;
}

void vdSetCounterPayTipFromStruct(VS_BOOL fCounterPayTip, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetCounterPayTip(fCounterPayTip);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fCounterPayTip = fCounterPayTip;
}

VS_BOOL fGetOTabSettleFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetOTabSettle();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fOTabSettle;
}

void vdSetOTabSettleFromStruct(VS_BOOL fOTabSettle, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetOTabSettle(fOTabSettle);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fOTabSettle = fOTabSettle;
}

VS_BOOL fGetUnadjTipFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetUnadjTip();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fUnadjTip;
}

void vdSetUnadjTipFromStruct(VS_BOOL fUnadjTip, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetUnadjTip(fUnadjTip);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fUnadjTip = fUnadjTip;
}

VS_BOOL fGetKeyInvNumFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetKeyInvNum();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fKeyInvNum;
}

void vdSetKeyInvNumFromStruct(VS_BOOL fKeyInvNum, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetKeyInvNum(fKeyInvNum);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fKeyInvNum = fKeyInvNum;
}

VS_BOOL fGetMultiMerchPromptFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetMultiMerchPrompt();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fMultiMerchPrompt;
}

void vdSetMultiMerchPromptFromStruct(VS_BOOL fMultiMerchPrompt, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetMultiMerchPrompt(fMultiMerchPrompt);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fMultiMerchPrompt = fMultiMerchPrompt;
}

VS_BOOL fGetDebitFlagFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetDebitFlag();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fDebitFlag;
}

void vdSetDebitFlagFromStruct(VS_BOOL fDebitFlag, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetDebitFlag(fDebitFlag);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fDebitFlag = fDebitFlag;
}

VS_BOOL fGetCashTipOnFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetCashTipOn();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fCashTipOn;
}

void vdSetCashTipOnFromStruct(VS_BOOL fCashTipOn, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetCashTipOn(fCashTipOn);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fCashTipOn = fCashTipOn;
}

VS_BOOL fGetMegaPasswordFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetMegaPassword();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fMegaPassword;
}

void vdSetMegaPasswordFromStruct(VS_BOOL fMegaPassword, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetMegaPassword(fMegaPassword);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fMegaPassword = fMegaPassword;
}

VS_BOOL fGetSugTipOnFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetSugTipOn();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fSugTipOn;
}

void vdSetSugTipOnFromStruct(VS_BOOL fSugTipOn, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetSugTipOn(fSugTipOn);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fSugTipOn = fSugTipOn;
}

VS_BOOL fGetUniqueIDPanFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetUniqueIDPan();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fUniqueIDPan;
}

void vdSetUniqueIDPanFromStruct(VS_BOOL fUniqueIDPan, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetUniqueIDPan(fUniqueIDPan);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fUniqueIDPan = fUniqueIDPan;
}

VS_BOOL fGetDualCurrencyFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetDualCurrency();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fDualCurrency;
}

void vdSetDualCurrencyFromStruct(VS_BOOL fDualCurrency, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetDualCurrency(fDualCurrency);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fDualCurrency = fDualCurrency;
}

VS_BOOL fGetAutoAnswerFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetAutoAnswer();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fAutoAnswer;
}

void vdSetAutoAnswerFromStruct(VS_BOOL fAutoAnswer, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetAutoAnswer(fAutoAnswer);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fAutoAnswer = fAutoAnswer;
}

VS_BOOL fGetDebitPredialFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetDebitPredial();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fDebitPredial;
}

void vdSetDebitPredialFromStruct(VS_BOOL fDebitPredial, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetDebitPredial(fDebitPredial);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fDebitPredial = fDebitPredial;
}

VS_BOOL fGetPromptLanguageFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetPromptLanguage();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fPromptLanguage;
}

void vdSetPromptLanguageFromStruct(VS_BOOL fPromptLanguage, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetPromptLanguage(fPromptLanguage);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fPromptLanguage = fPromptLanguage;
}

VS_BOOL fGetCustomerSwipeFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetCustomerSwipe();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fCustomerSwipe;
}

void vdSetCustomerSwipeFromStruct(VS_BOOL fCustomerSwipe, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetCustomerSwipe(fCustomerSwipe);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fCustomerSwipe = fCustomerSwipe;
}

VS_BOOL fGetImamForceSettleFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetImamForceSettle();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fImamForceSettle;
}

void vdSetImamForceSettleFromStruct(VS_BOOL fImamForceSettle, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamForceSettle(fImamForceSettle);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fImamForceSettle = fImamForceSettle;
}

VS_BOOL fGetImamReferralFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetImamReferral();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fImamReferral;
}

void vdSetImamReferralFromStruct(VS_BOOL fImamReferral, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamReferral(fImamReferral);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fImamReferral = fImamReferral;
}

VS_BOOL fGetImamAirlineTrxFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetImamAirlineTrx();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fImamAirlineTrx;
}

void vdSetImamAirlineTrxFromStruct(VS_BOOL fImamAirlineTrx, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamAirlineTrx(fImamAirlineTrx);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fImamAirlineTrx = fImamAirlineTrx;
}

VS_BOOL fGetImamPrintPromptFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetImamPrintPrompt();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fImamPrintPrompt;
}

void vdSetImamPrintPromptFromStruct(VS_BOOL fImamPrintPrompt, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamPrintPrompt(fImamPrintPrompt);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fImamPrintPrompt = fImamPrintPrompt;
}

VS_BOOL fGetImamSendVoidedFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetImamSendVoided();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fImamSendVoided;
}

void vdSetImamSendVoidedFromStruct(VS_BOOL fImamSendVoided, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamSendVoided(fImamSendVoided);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fImamSendVoided = fImamSendVoided;
}

VS_BOOL fGetImamReportPerCardFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return fGetImamReportPerCard();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((TCT_REC*)vdStruct)->fImamReportPerCard;
}

void vdSetImamReportPerCardFromStruct(VS_BOOL fImamReportPerCard, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamReportPerCard(fImamReportPerCard);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((TCT_REC*)vdStruct)->fImamReportPerCard = fImamReportPerCard;
}

